package com.snapan.controller;

import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.OSSObject;
import com.snapan.config.OssConfig;
import com.snapan.entity.FileBase;
import com.snapan.entity.FileChunk;
import com.snapan.entity.UserFile;
import com.snapan.service.FileBaseService;
import com.snapan.service.FileChunkService;
import com.snapan.service.UserFileService;
import com.snapan.service.OssService;
import com.snapan.util.FileUtils;
import org.codelibs.jhighlight.fastutil.Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.*;

/**
 * 文件基础信息表控制器
 */
@RestController
@RequestMapping("/api/filebase")
public class FileBaseController {

    @Autowired
    private FileBaseService filebaseService;

    @Autowired
    private FileChunkService fileChunkService;

    @Autowired
    private UserFileService userFileService;

    @Autowired
    private OssService ossService;

    @Value("${file.upload.path:/uploads}")
    private String uploadPath;

    @Value("${file.chunk.path:/uploads/chunks}")
    private String chunkPath;


    /**
     * 获取列表
     */
    @GetMapping("/list")
    public Map<String, Object> getList() {
        Map<String, Object> result = new HashMap<>();
        try {
            List<FileBase> list = filebaseService.getAll();
            result.put("success", true);
            result.put("data", list);
            result.put("message", "获取列表成功");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取列表失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 根据ID获取
     */
    @GetMapping("/{id}")
    public Map<String, Object> getById(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        try {
            FileBase filebase = filebaseService.getById(id);
            if (filebase != null) {
                result.put("success", true);
                result.put("data", filebase);
                result.put("message", "获取成功");
            } else {
                result.put("success", false);
                result.put("message", "数据不存在");
            }
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取失败：" + e.getMessage());
        }
        return result;
    }


    /**
     * 获取文件预览的签名url
     * @param filePath oss文件中的路径
     * @return 包含url和文件类型的json
     */
    @GetMapping("/getPreviewUrl")
    @ResponseBody
    public Map<String,String> getPreviewUrl(String filePath){
        Map<String,String> result=new HashMap<>();
        try{
            //生成1小时有效的签名url
            // 手动去除URL中的域名，只保留相对路径
            String ossDomain = "https://snapan.oss-cn-beijing.aliyuncs.com/";
            if (filePath.startsWith(ossDomain)) {
                filePath = filePath.substring(ossDomain.length()); // 截取后得到 "1761277048722.jpg"
            }
            // 生成签名URL（此时filePath是相对路径）
            String previewUrl=ossService.generatePreviewUrl(filePath,3600);
            System.out.println(previewUrl);
            System.out.println(filePath);
            //获取文件后缀
            String fileType=getFileSuffix(filePath);
            result.put("code","200");
            result.put("previewUrl",previewUrl);
            result.put("fileType",fileType);
        }catch (Exception e){
            result.put("code","500");
            result.put("msg","生成预览链接失败:"+e.getMessage());
        }
        return result;
    }

    //提取文件后缀
    private String getFileSuffix(String fileName){
        if(fileName.lastIndexOf(".")==-1){
            return "";//无后缀
        }
        return fileName.substring(fileName.lastIndexOf(".")+1).toLowerCase();
    }

    /**
     * 文件下载接口（基于OSS）
     * 从OSS下载文件并返回给用户
     */
    @GetMapping("/download/{fileId}")
    public void downloadFile(@PathVariable Long fileId, HttpServletResponse response) {
        try {
            // 1. 查询文件基础信息
            // 首先尝试直接通过fileId查询（filebase表）
            FileBase fileBase = filebaseService.getById(fileId);

            // 如果直接查询失败，尝试通过userfile表查询
            if (fileBase == null) {
                try {
                    // 通过userfile表查询
                    UserFile userFile = userFileService.getById(fileId);
                    if (userFile != null && userFile.getFileBaseId() != null) {
                        fileBase = filebaseService.getById(userFile.getFileBaseId());
                    }
                } catch (Exception e) {
                    // 查询失败，继续使用fileBase = null
                }
            }

            if (fileBase == null) {
                response.sendError(HttpServletResponse.SC_NOT_FOUND, "文件不存在");
                return;
            }

            // 2. 获取OSS URL
            String ossUrl = fileBase.getFilePath();
            if (ossUrl == null || ossUrl.isEmpty()) {
                response.sendError(HttpServletResponse.SC_NOT_FOUND, "文件URL不存在");
                return;
            }

            // 3. 从OSS下载文件
            try {
                // 获取原始文件名
                String fileName = fileBase.getRealName();
                if (fileName == null || fileName.isEmpty()) {
                    fileName = fileBase.getFileName();
                }

                // 设置响应头
                response.setContentType("application/octet-stream");
                response.setContentLengthLong(fileBase.getFileSize());
                response.setHeader("Content-Disposition", "attachment; filename=\"" +
                        java.net.URLEncoder.encode(fileName, "UTF-8") + "\"");
                response.setHeader("Cache-Control", "no-cache");

                // 从OSS URL中提取文件名
                String ossFileName = ossUrl.substring(ossUrl.lastIndexOf("/") + 1);
                String downloadUrl = ossService.generateSignedUrl(ossFileName, 60); // 1小时有效期

                // 从OSS下载文件并写入响应流
                java.net.URL url = new java.net.URL(downloadUrl);

                try (InputStream ossInputStream = url.openStream();
                     OutputStream responseOutputStream = response.getOutputStream()) {

                    byte[] buffer = new byte[8192]; // 8KB缓冲区，提高下载速度
                int len;
                    while ((len = ossInputStream.read(buffer)) != -1) {
                        responseOutputStream.write(buffer, 0, len);
                    }
                    responseOutputStream.flush();
                }

            } catch (Exception e) {
                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                        "下载失败：" + e.getMessage());
            }

        } catch (IOException e) {
            try {
                response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                        "下载失败：" + e.getMessage());
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * 检查文件ID和OSS文件名的匹配关系
     * 用于调试文件名不匹配问题
     */
    @GetMapping("/check-file-mapping/{fileId}")
    public Map<String, Object> checkFileMapping(@PathVariable Long fileId) {
        Map<String, Object> result = new HashMap<>();
        try {
            FileBase fileBase = filebaseService.getById(fileId);
            if (fileBase == null) {
                result.put("success", false);
                result.put("message", "文件不存在");
                return result;
            }

            String filePath = fileBase.getFilePath();
            result.put("success", true);
            result.put("fileId", fileId);
            result.put("realName", fileBase.getRealName());
            result.put("fileName", fileBase.getFileName());
            result.put("filePath", filePath);

            // 分析文件路径
            if (filePath != null) {
                int lastSlash = filePath.lastIndexOf("/");
                String extractedFileName = lastSlash >= 0 ? filePath.substring(lastSlash + 1) : filePath;
                result.put("extractedFileName", extractedFileName);
                result.put("lastSlashPosition", lastSlash);

                // 检查文件名是否匹配
                boolean nameMatch = fileBase.getFileName().equals(extractedFileName);
                result.put("nameMatch", nameMatch);

                if (!nameMatch) {
                    result.put("warning", "数据库文件名与路径中提取的文件名不匹配");
                    result.put("databaseFileName", fileBase.getFileName());
                    result.put("extractedFileName", extractedFileName);
                }
            }

        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "检查失败：" + e.getMessage());
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 检查文件URL格式
     * 专门用于调试URL格式问题
     */
    @GetMapping("/check-url/{fileId}")
    public Map<String, Object> checkFileUrl(@PathVariable Long fileId) {
        Map<String, Object> result = new HashMap<>();
        try {
            FileBase fileBase = filebaseService.getById(fileId);
            if (fileBase == null) {
                result.put("success", false);
                result.put("message", "文件不存在");
                return result;
            }

            String filePath = fileBase.getFilePath();
            result.put("success", true);
            result.put("fileId", fileId);
            result.put("filePath", filePath);
            result.put("filePathLength", filePath != null ? filePath.length() : 0);
            result.put("startsWithHttp", filePath != null && filePath.startsWith("http"));
            result.put("startsWithHttps", filePath != null && filePath.startsWith("https"));
            result.put("isOssUrl", filePath != null && (filePath.startsWith("http") || filePath.startsWith("https")));

            // 详细分析URL
            if (filePath != null) {
                result.put("firstChar", filePath.length() > 0 ? filePath.charAt(0) : "null");
                result.put("first10Chars", filePath.length() >= 10 ? filePath.substring(0, 10) : filePath);
                result.put("containsOss", filePath.contains("oss"));
                result.put("containsSnapan", filePath.contains("snapan"));
            }

        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "检查失败：" + e.getMessage());
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 测试文件信息接口
     * 用于调试下载问题
     */
    @GetMapping("/debug/{fileId}")
    public Map<String, Object> debugFile(@PathVariable Long fileId) {
        Map<String, Object> result = new HashMap<>();
        try {
            FileBase fileBase = filebaseService.getById(fileId);
            if (fileBase == null) {
                result.put("success", false);
                result.put("message", "文件不存在");
                return result;
            }

            result.put("success", true);
            result.put("data", fileBase);
            result.put("message", "文件信息获取成功");

            // 额外信息
            Map<String, Object> debugInfo = new HashMap<>();
            debugInfo.put("id", fileBase.getId());
            debugInfo.put("realName", fileBase.getRealName());
            debugInfo.put("fileName", fileBase.getFileName());
            debugInfo.put("filePath", fileBase.getFilePath());
            debugInfo.put("fileSize", fileBase.getFileSize());
            debugInfo.put("fileType", fileBase.getFileType());
            debugInfo.put("status", fileBase.getStatus());
            debugInfo.put("createTime", fileBase.getCreateTime());

            // 检查文件类型
            String filePath = fileBase.getFilePath();
            if (filePath != null && filePath.startsWith("http")) {
                debugInfo.put("fileLocation", "OSS");
                debugInfo.put("isOssFile", true);
            } else {
                debugInfo.put("fileLocation", "本地");
                debugInfo.put("isOssFile", false);
                debugInfo.put("warning", "此文件未上传到OSS，需要重新上传");
            }

            result.put("debugInfo", debugInfo);

        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取文件信息失败：" + e.getMessage());
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 获取文件签名下载URL
     * 返回带签名的临时访问链接
     */
    @GetMapping("/signed-url/{fileId}")
    public Map<String, Object> getSignedUrl(@PathVariable Long fileId,
                                            @RequestParam(defaultValue = "60") int expirationMinutes) {
        Map<String, Object> result = new HashMap<>();
        try {
            // 查询文件基础信息
            // 首先尝试直接通过fileId查询（filebase表）
            FileBase fileBase = filebaseService.getById(fileId);

            // 如果直接查询失败，尝试通过userfile表查询
            if (fileBase == null) {
                try {
                    // 通过userfile表查询
                    UserFile userFile = userFileService.getById(fileId);
                    if (userFile != null && userFile.getFileBaseId() != null) {
                        fileBase = filebaseService.getById(userFile.getFileBaseId());
                    }
                } catch (Exception e) {
                    // 查询失败，继续使用fileBase = null
                }
            }

            if (fileBase == null) {
                result.put("success", false);
                result.put("message", "文件不存在");
                return result;
            }

            // 获取OSS URL
            String ossUrl = fileBase.getFilePath();
            if (ossUrl == null || ossUrl.isEmpty()) {
                result.put("success", false);
                result.put("message", "文件URL不存在");
                return result;
            }

            // 从OSS URL中提取文件名
            String ossFileName = ossUrl.substring(ossUrl.lastIndexOf("/") + 1);

            // 生成签名URL
            String signedUrl = ossService.generateSignedUrl(ossFileName, expirationMinutes);

            result.put("success", true);
            result.put("data", signedUrl);
            result.put("message", "获取签名URL成功");
            result.put("fileName", fileBase.getRealName());
            result.put("fileSize", fileBase.getFileSize());
            result.put("fileType", fileBase.getFileType());
            result.put("expirationMinutes", expirationMinutes);
            result.put("expirationTime", new java.util.Date(System.currentTimeMillis() + expirationMinutes * 60 * 1000));

        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取签名URL失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 获取文件下载URL（返回OSS直链）
     * 适用于前端直接下载的场景
     */
    @GetMapping("/download-url/{fileId}")
    public Map<String, Object> getDownloadUrl(@PathVariable Long fileId) {
        Map<String, Object> result = new HashMap<>();
        try {
            // 查询文件基础信息
            FileBase fileBase = filebaseService.getById(fileId);
            if (fileBase == null) {
                result.put("success", false);
                result.put("message", "文件不存在");
                return result;
            }

            // 获取OSS URL
            String ossUrl = fileBase.getFilePath();
            if (ossUrl == null || ossUrl.isEmpty()) {
                result.put("success", false);
                result.put("message", "文件URL不存在");
                return result;
            }

            result.put("success", true);
            result.put("data", ossUrl);
            result.put("message", "获取下载链接成功");
            result.put("fileName", fileBase.getRealName());
            result.put("fileSize", fileBase.getFileSize());
            result.put("fileType", fileBase.getFileType());

        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取下载链接失败：" + e.getMessage());
        }
        return result;
    }


    /**
     * 添加
     */
    @PostMapping("/add")
    public Map<String, Object> add(@RequestBody FileBase filebase) {
        Map<String, Object> result = new HashMap<>();
        try {
            boolean success = filebaseService.add(filebase);
            result.put("success", success);
            result.put("message", success ? "添加成功" : "添加失败");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "添加失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 更新
     */
    @PutMapping("/update")
    public Map<String, Object> update(@RequestBody FileBase filebase) {
        Map<String, Object> result = new HashMap<>();
        try {
            boolean success = filebaseService.update(filebase);
            result.put("success", success);
            result.put("message", success ? "更新成功" : "更新失败");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "更新失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 软删除（回收站）
     */
    @DeleteMapping("/{id}")
    public Map<String, Object> delete(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        try {
            boolean success = userFileService.softDelete(id);
            result.put("success", success);
            result.put("message", success ? "已移动到回收站" : "删除失败");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "删除失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 检查文件是否存在
     */
    @PostMapping("/check")
    public Map<String, Object> checkUpload(@RequestParam String fileName,
                                           @RequestParam Long fileSize,
                                           @RequestParam String fileMD5,
                                           @RequestParam(required = false) Integer userId) {
        Map<String, Object> result = new HashMap<>();
        try {
            // 检查文件是否已存在
            FileBase existingFile = filebaseService.getByMD5AndSize(fileMD5, fileSize);
            if (existingFile != null && existingFile.getStatus() == 1) {
                result.put("success", true);
                result.put("exists", true);
                result.put("message", "文件已存在");
                result.put("fileId", existingFile.getId());
            } else {
                result.put("success", true);
                result.put("exists", false);
                result.put("message", "文件不存在");
            }
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "检查失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 分片上传
     */
    @PostMapping("/upload-chunk")
    public Map<String, Object> uploadChunk(@RequestParam("file") MultipartFile file,
                                           @RequestParam("chunkIndex") Integer chunkIndex,
                                           @RequestParam("totalChunks") Integer totalChunks,
                                           @RequestParam("fileName") String fileName,
                                           @RequestParam("fileSize") Long fileSize,
                                           @RequestParam("fileMD5") String fileMD5,
                                           @RequestParam(required = false) Integer userId) {
        Map<String, Object> result = new HashMap<>();
        try {
            // 创建或获取文件基础信息（只在第一个分片时创建）
            FileBase fileBase = filebaseService.getByMD5AndSize(fileMD5, fileSize);
            if (fileBase == null && chunkIndex == 0) {
                fileBase = new FileBase();
                fileBase.setRealName(fileName);
                // 提取并设置文件后缀（如 .pdf/.jpg），统一为小写
                String suffix = null;
                if (fileName != null) {
                    int dot = fileName.lastIndexOf('.');
                    if (dot >= 0 && dot < fileName.length() - 1) {
                        suffix = fileName.substring(dot).toLowerCase();
                    }
                }
                fileBase.setSuffix(suffix);
                fileBase.setFileName(FileUtils.generateStorageFileName(fileName));
                fileBase.setFileMd5(fileMD5);
                fileBase.setFileSize(fileSize);
                fileBase.setChunkCount(totalChunks);
                fileBase.setChunkSize((fileSize + totalChunks - 1) / totalChunks);
                fileBase.setFileType("application/octet-stream");
                fileBase.setFilePath("");
                fileBase.setStatus((byte) 0);
                fileBase.setCreateBy("system"); // 使用默认用户
                filebaseService.add(fileBase);
            } else if (fileBase == null && chunkIndex > 0) {
                throw new RuntimeException("文件基础信息不存在，但分片索引大于0");
            }

            // 保存分片文件
            String chunkFileName = FileUtils.generateChunkFileName(fileMD5, chunkIndex + 1);
            String chunkFilePath = FileUtils.saveChunkFile(file, chunkPath, chunkFileName);
            String absoluteChunkFilePath = new File(chunkFilePath).getAbsolutePath();

            // 检查分片是否已经存在（断点续传）
            List<FileChunk> existingChunks = fileChunkService.getByFileBaseId(fileBase.getId());
            boolean chunkExists = existingChunks.stream()
                    .anyMatch(chunk -> chunk.getChunkNumber().equals(chunkIndex + 1));

            boolean success = true;
            if (!chunkExists) {
                // 保存分片信息
                FileChunk fileChunk = new FileChunk();
                fileChunk.setFileBaseId(fileBase.getId());
                fileChunk.setFileName(fileName);
                fileChunk.setChunkNumber(chunkIndex + 1);
                fileChunk.setChunkSize(file.getSize());
                fileChunk.setCurrentChunkSize(file.getSize());
                fileChunk.setTotalSize(fileSize);
                fileChunk.setTotalChunk(totalChunks);
                fileChunk.setIdentifier(fileMD5);
                fileChunk.setRelativePath(absoluteChunkFilePath);
                fileChunk.setStatus((byte) 1);
                fileChunk.setCreateBy("system");
                success = fileChunkService.uploadFile(fileChunk);
            }

            result.put("success", success);
            result.put("message", success ? "分片上传成功" : "分片上传失败");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "分片上传失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 文件合并接口
     * 用于将上传的文件分片合并为完整文件，并完成相关元数据更新
     * 支持大文件断点续传功能的最终合并步骤
     */
    @PostMapping("/merge")
    public Map<String, Object> mergeFile(
            @RequestParam("fileName") String fileName,       // 文件名
            @RequestParam("fileSize") Long fileSize,         // 文件总大小
            @RequestParam("fileMD5") String fileMD5,         // 文件MD5值
            @RequestParam(required = false) Integer userId,  // 可选参数：用户ID，用于关联用户与文件
            @RequestParam(required = false, defaultValue = "0") Long parentId) { // 可选参数：父目录ID，默认为0（根目录）

        // 初始化返回结果集合
        Map<String, Object> result = new HashMap<>();

        try {
            // 1. 根据文件MD5和大小查找对应的文件基础信息记录
            // FileBase存储文件的元数据信息(名称、大小、路径等)
            FileBase fileBase = filebaseService.getByMD5AndSize(fileMD5, fileSize);

            // 校验文件基础信息是否存在
            if (fileBase == null) {
                result.put("success", false);
                result.put("message", "文件基础信息不存在");
                return result;
            }

            // 2. 获取该文件对应的所有分片记录
            // FileChunk存储每个分片的信息(分片序号、存储路径等)
            List<FileChunk> chunks = fileChunkService.getByFileBaseId(fileBase.getId());

            // 校验分片记录是否存在
            if (chunks.isEmpty()) {
                result.put("success", false);
                result.put("message", "分片信息不存在");
                return result;
            }

            // 3. 准备文件合并
            // 3.1 确定合并后的文件最终存储路径
            String finalFilePath = uploadPath + "/" + fileBase.getFileName();

            // 3.2 处理分片路径：按分片序号排序(确保合并顺序正确)，提取所有分片的存储路径
            String[] chunkFilePaths = chunks.stream()
                    .sorted(Comparator.comparing(FileChunk::getChunkNumber))  // 按分片编号升序排列
                    .map(FileChunk::getRelativePath)                          // 提取分片文件路径
                    .toArray(String[]::new);                                   // 转换为数组

            // 3.3 调用工具类合并所有分片文件
            FileUtils.mergeChunkFiles(chunkFilePaths, finalFilePath);

            // 4. 将合并后的文件上传到OSS
            File mergedFile = new File(finalFilePath);
            String ossUrl = ossService.uploadFile(
                    new java.io.FileInputStream(mergedFile),
                    fileBase.getFileName(),
                    fileBase.getFileType(),
                    fileBase.getFileSize()
            );

            // 删除本地临时文件
            mergedFile.delete();

            // 5. 更新文件基础信息
            fileBase.setFilePath(ossUrl);       // 设置OSS URL
            fileBase.setStatus((byte) 1);               // 更新状态为"已完成"(1表示完成)
            fileBase.setUpdateBy("system");             // 设置更新操作人为系统
            // 若缺失后缀，则根据传入的文件名回填
            if (fileBase.getSuffix() == null || fileBase.getSuffix().isEmpty()) {
                String suffix = null;
                if (fileName != null) {
                    int dot = fileName.lastIndexOf('.');
                    if (dot >= 0 && dot < fileName.length() - 1) {
                        suffix = fileName.substring(dot).toLowerCase();
                    }
                }
                fileBase.setSuffix(suffix);
            }
            filebaseService.update(fileBase);           // 保存更新

            // 5. 清理临时分片文件(释放存储空间)
            for (String chunkFilePath : chunkFilePaths) {
                FileUtils.deleteFile(chunkFilePath);
            }

            long userFileId;
            // 6. 若存在用户ID，创建用户与文件的关联记录
            if (userId != null) {
                UserFile userFile = new UserFile();
                userFile.setUserId(userId.longValue());     // 设置关联的用户ID
                userFile.setFileBaseId(fileBase.getId());   // 设置关联的文件基础信息ID
                userFile.setFileName(fileName);             // 设置用户可见的文件名
                userFile.setParentId(parentId);            // 设置父目录ID
                userFile.setIsDirectory((byte) 0);          // 标记为文件(0表示非目录)
                userFile.setStatus((byte) 1);               // 设置状态为"有效"
                userFile.setStatus((byte) 1);               // 设置状态为"有效"
                userFile.setCreateTime(new java.util.Date());// 设置创建时间
                userFile.setUpdateTime(new java.util.Date());// 设置更新时间

                // 保存用户文件关联记录
                boolean userFileAdded = userFileService.add(userFile);
                if (!userFileAdded) {
                    // 记录关联失败日志(不影响主流程)
                    System.err.println("创建用户文件关联记录失败");
                }
                else{
                    userFileId=userFile.getId();
                    //上传到Es库
                    // 单独捕获ES同步的异常，便于区分错误类型
                    try {
                        userFileService.syncUserFileToEs(userFileId);
                    } catch (RuntimeException e) {
                        // 此处专门处理ES同步失败的情况
                        throw new RuntimeException("文件同步失败：" + e.getMessage());
                    }
                }
            }

            // 7. 合并成功，设置返回结果
            result.put("success", true);
            result.put("message", "文件合并成功");
            result.put("fileId", fileBase.getId());        // 返回合并后的文件ID

        } catch (RuntimeException e) {
            // 区分异常类型：如果是ES同步失败，直接使用其message；否则使用通用消息
            if (e.getMessage().startsWith("文件同步失败：")) {
                result.put("message", e.getMessage());
            } else {
                result.put("message", "文件合并失败：" + e.getMessage());
            }
            result.put("success", false);
        } catch (Exception e) {
            // 捕获所有异常，返回失败信息
            result.put("success", false);
            result.put("message", "文件合并失败：" + e.getMessage());
        }

        return result;
    }



}























